Kanwal Mehreen writes that as large language models move from chatbots to coding agents and autonomous workflows, good prompting is no longer enough and specification engineering is emerging as the key skill. It is the practice of defining goals, constraints, expected outputs, edge cases, tests, success criteria and failure modes so AI-assisted work is testable and reviewable. Prompt engineering asks how to ask, while specification engineering defines what done correctly means, a shift closer to product management, testing and research design than traditional prompting.
- A 2024 Requirement-Oriented Prompt Engineering paper found ROPE training improved requirement-writing ability by 20% versus 1% for conventional prompt engineering training.
- OpenAI Structured Outputs, Model Spec and Anthropic Constitution exemplify specification engineering at API and model-behavior levels.
- SWE-bench Verified is a human-validated subset used to evaluate real-world software issue solving with agents.
- Google's 2025 DORA report surveyed nearly 5,000 tech professionals and found AI amplifies existing organizational strengths and weaknesses.
- A 2024 Requirement-Oriented Prompt Engineering paper found ROPE training improved requirement-writing ability by 20% versus 1% for conventional prompt engineering training.
- OpenAI Structured Outputs, Model Spec and Anthropic Constitution exemplify specification engineering at API and model-behavior levels.
- SWE-bench Verified is a human-validated subset used to evaluate real-world software issue solving with agents.
- Google's 2025 DORA report surveyed nearly 5,000 tech professionals and found AI amplifies existing organizational strengths and weaknesses.
Microsoft’s POML offers a declarative way to manage complex instructions by using XML-like tags and CSS-style rules for prompt design. By separating content from stylistic parameters like tone and token limits, the system promotes modularity, reusability, and improved maintainability compared to manual string concatenation.
- Requires Python 3.10 or higher
- Facilitates cleaner version control through structured diffs in pull requests
- Enables non-engineers like product managers to contribute using familiar syntax styles
- Allows for model-agnostic structures that separate intent from specific API formatting quirks
- Requires Python 3.10 or higher
- Facilitates cleaner version control through structured diffs in pull requests
- Enables non-engineers like product managers to contribute using familiar syntax styles
- Allows for model-agnostic structures that separate intent from specific API formatting quirks
Yuge Zhang writes about Prompt Orchestration Markup Language (POML), a framework designed to manage complex prompt structures and diverse data types for Large Language Models. It uses component-based markup and specialized tags to integrate documents, tables, and images while employing a CSS-like styling system to decouple content from its presentation format. This approach aims to reduce formatting sensitivity and improve the reliability of prompts when interacting with models.
- Validated through PomLink application integration and TableQA accuracy tests.
- Includes templating for dynamic prompt generation and an SDK/IDE toolkit.
- Designed to enhance version control and collaboration in development workflows.
- Validated through PomLink application integration and TableQA accuracy tests.
- Includes templating for dynamic prompt generation and an SDK/IDE toolkit.
- Designed to enhance version control and collaboration in development workflows.
Yuge Zhang et al. write about Prompt Orchestration Markup Language (POML), a markup language designed to bring structure, maintainability, and versatility to prompt engineering for Large Language Models. By employing an HTML-like syntax, POML modularizes components such as roles and tasks while decoupling content from presentation via a CSS-inspired styling system.
- Includes built-in templating with support for variables, loops, and conditionals
- Provides SDKs for Python and Node.js integration into application workflows
- Offers a Visual Studio Code extension featuring syntax highlighting and real-time previews
- Supports seamless embedding of external data sources like images and spreadsheets via specialized components
- Includes built-in templating with support for variables, loops, and conditionals
- Provides SDKs for Python and Node.js integration into application workflows
- Offers a Visual Studio Code extension featuring syntax highlighting and real-time previews
- Supports seamless embedding of external data sources like images and spreadsheets via specialized components
Emmimal P Alexander writes that while prompt engineering focuses on optimizing LLM inputs, managing these templates within evolving codebases often leads to production crashes when variables are renamed or removed. To solve this, she created `promptctl`, a Python tool that applies static analysis—similar to database schema migrations—to ensure prompt variable contracts match their call sites in the codebase.
- Performs PromptDiff (detects changes), Contract Validation (checks mismatches), and Impact Analysis (traces dependencies).
- Operates strictly via AST parsing, requiring zero LLM calls or API keys.
- Detects errors that unit tests often miss by mocking away the actual string formatting step.
- Performs PromptDiff (detects changes), Contract Validation (checks mismatches), and Impact Analysis (traces dependencies).
- Operates strictly via AST parsing, requiring zero LLM calls or API keys.
- Detects errors that unit tests often miss by mocking away the actual string formatting step.
>"Enterprise Document Intelligence – A fixed BASE, the rules each question needs, one registry: the dispatcher that turns a parsed question into a typed LLM call"
Instead of "mega-prompts," use a Dispatcher Pattern to assemble a `BASE` prompt with specific fragments (shape and constraints) at runtime. This improves accuracy, simplifies maintenance, and aids auditing.
* Modular Prompting: Uses "shape fragments" (formatting/extraction) and "constraint fragments" (specific rules).
* Execution Modes: Combined (sends all chunks at once) vs sequential (Iterative chunk processing to save costs)
* Structural Scoping: Uses query hints (e.g., page numbers) to refine retrieval.
* Best Practices: Use Temperature 0, maintain a 20–30% context window buffer, and log raw model responses.
Instead of "mega-prompts," use a Dispatcher Pattern to assemble a `BASE` prompt with specific fragments (shape and constraints) at runtime. This improves accuracy, simplifies maintenance, and aids auditing.
* Modular Prompting: Uses "shape fragments" (formatting/extraction) and "constraint fragments" (specific rules).
* Execution Modes: Combined (sends all chunks at once) vs sequential (Iterative chunk processing to save costs)
* Structural Scoping: Uses query hints (e.g., page numbers) to refine retrieval.
* Best Practices: Use Temperature 0, maintain a 20–30% context window buffer, and log raw model responses.
>"Using DSPy to automatically create, evaluate, and optimize your prompts"
Manual prompt engineering is often slow and unreliable due to unpredictable inputs. DSPy addresses this by treating prompt development like traditional ML training. It automatically generates, evaluates (using "LLM-as-a-judge"), and optimizes prompts based on high-level task descriptions, providing a faster, more systematic way to build robust LLM applications.
Manual prompt engineering is often slow and unreliable due to unpredictable inputs. DSPy addresses this by treating prompt development like traditional ML training. It automatically generates, evaluates (using "LLM-as-a-judge"), and optimizes prompts based on high-level task descriptions, providing a faster, more systematic way to build robust LLM applications.
Local large language models often struggle with ambiguous prompts because they lack the massive datasets and scale used by cloud-based AI to infer user intent. To improve accuracy, users can implement a custom system prompt that instructs the model to ask up to three targeted clarifying questions before performing complex tasks like coding or writing. This approach reduces errors caused by incorrect assumptions and helps refine user instructions through active dialogue.
>"""When tasked with coding, writing, editing, or summarizing, ask the user up to three targeted clarifying questions. Proceed with the task once you've received answers and understand the prompt fully. If the task is a simple factual question or conversational message, respond directly.
"""
>"""When tasked with coding, writing, editing, or summarizing, ask the user up to three targeted clarifying questions. Proceed with the task once you've received answers and understand the prompt fully. If the task is a simple factual question or conversational message, respond directly.
"""
Simon Willison discusses why requesting HTML rather than Markdown as an LLM output format can significantly enhance technical explanations. While token constraints previously favored Markdown, modern models benefit from the ability of HTML to incorporate SVG diagrams, interactive widgets, and improved navigation. The article provides prompt examples for reviewing pull requests via HTML artifacts and showcases a GPT-5.5 generated explanation of a Linux security exploit that uses CSS and JavaScript to create a rich documentation experience.
This handbook provides a comprehensive introduction to Claude Code, Anthropic's AI-powered software development agent. It details how Claude Code differs from traditional autocomplete tools, functioning as an agent that reads, reasons about, and modifies codebases with user direction. The guide covers installation, initial setup, advanced workflows, integrations, and autonomous loops. It's aimed at developers, founders, and anyone seeking to leverage AI in software creation, emphasizing building real applications, accelerating feature development, and maintaining codebases efficiently. The handbook also highlights the importance of prompt discipline, planning, and understanding the underlying model to maximize Claude Code's capabilities.
